Symbols
! (logical negation operator)

! (logical NOT)

!= (bitwise inclusive OR assignment operator)

!= (inequality operator)

!= (relational is not equal to operator)

# flag
# preprocessor operator

## preprocessor operator

#define

#define NDEBUG

#define PI 3.14159

#define preprocessor directive

#elif

#endif

#error

#if

#ifdef

#ifndef

#include
#include "filename"

#include <algorithm>
#include <filename>

#include <functional>
#include <iomanip.h>

#include <iostream.h>

#include <iostream>

#include <iso646.h>
#include <iterator>
#include <list>
#include <math.h>
#include <numeric>
#include <queue>

#include <set>
#include <signal.h>
#include <sstream>
#include <stack>
#include <string.h>

#include <vector>
#include preprocessor directive

#line

#pragma

#undef preprocessor directive

$ UNIX command line prompt

% (modulus operator)

% floating-point conversion specifiers

% prompt

%= (modulus assignment operator)

& (address operator)

& (bitwise AND operator)

& and * operators as inverses

& in a parameter list

& to declare reference

&& (logical AND operator)

&= (bitwise AND assignment operator)

( type ) (C-style unary cast operator)

() (parentheses operator)

() in a function call

(FCB)

* (dereference operator)

* (multiplication operator)

** operator in BASIC for exponentiation

*= (multiplication assignment operator)

+ (addition operator)

+ (unary plus operator)

+ flag

++ (unary postincrement operator)

++ (unary preincrement operator)

++ operation on an iterator

++ operator

++ unary increment operator

- (subtraction operator)

- (unary minus operator)

-- unary decrement operator

-- (unary postdecrement operator)

-- (unary predecrement operator)

-= (subtraction assignment operator)

-> (member selection via pointer operator)

->* (pointer to member via object operator)

->* (pointer to member via pointer operator)

+= (addition assignment operator)

, (comma operator)

. (member selection via object operator)

.* (pointer to member via object operator)

.* operator

/ (division operator)

// comment operator

/= (division assignment operator)

: (member initializer operator)

:: (binary scope resolution operator)

:: (unary scope resolution operator)

; semicolon

< (relational less than operator)

<< (bitwise left shift operator)

<< operator

<<= (bitwise left shift assignment operator)

<= (relational less than or equal to operator)

<stdio.h>

<stdio.h> header file

<typeinfo>

= (assignment operator)

== (relational is equal to operator)

> (relational greater than operator)

>= (relational greater than or equal to operator)

>> (bitwise right shift operator)

>> operator

>>= (bitwise right shift with sign operator)

?: (ternary conditional operator)

[] (array subscript operator)

\\" double-quote-character escape sequence

\\\\ backslash-character escape sequence

\\a alert escape sequence

\n newline escape sequence

\\r carriage-return escape sequence

\ horizontal-tab escape sequence

^ (bitwise exclusive OR operator)

^= (bitwise exclusive OR assignment operator)

__DATE__

__FILE__

__LINE__

__STDC__

__TIME__

{ } braces

| (bitwise inclusive OR operator)

| operator

|= (bitwise inclusive OR assignment operator)

|| (logical OR operator)

~ (unary bitwise complement operator)

Numerics
'\\0'

0 (zero) flag

0 pointer

32-bit representation

8 bytes

A
a+

a.out

abbreviated assignment operators

abbreviating assignment expressions

abbreviating lengthy binary representations

abnormal program termination

abort

abort a program

absolute value

abstract base class

abstract class

abstract data type

abstraction

acceptable match to the type of an exception

access a global variable

access an off handle member

access class member

access function

access non-static class data members and member functions

access privileges

access structure member

access the caller's data

access violation

accessibility of base-class members in derived class

accessing member of a structure

accessing union members

accessor method

accounts receivable

accounts receivable program

accounts receivable system

accumulate
accumulate() algorithm

accumulated outputs

accumulator

action

action symbol

action/decision model of computing

action/decision model of programming

action-oriented

action-oriented programming

actions

actions to be executed

Ada

adapters

add a new account to a file

add an integer to a pointer

addition

addition assignment operator (+=)

addition operator (+)

address (&) of a structure

address (&) of a union

address of a bit field

address operator (&)

addressable storage unit

adjacent_difference

adjacent_difference() algorithm

adjacent_find

adjacent-find() algorithm

adjusted fields

adjustfield

"administrative" section of the computer

ADTs (abstract data types)

airline reservation system

alert

alert escape sequence ('\\a')

algebraic expression

<algorithm>

algorithm

algorithms of the standard library

algorithms of the STL

algorithms separated from containers

alias

alias for a type

alias for the name of an object

aligning

alignment

allocate dynamic memory

allocate memory

allocate memory for substring
allocated space

allocator

alphabetizing strings

alter the flow of control

ALU

ambiguity

ambiguity problem

American National Standards Committee on Computers and Information Processing (X3)

American National Standards Institute (ANSI)

American Standard Code for Information Interchange

Analytical Engine

and

and_eq

"ANDed"

angle brackets (< and >)

animated graphical output

anonymous union

ANSI

ANSI C

ANSI C standard library functions

ANSI, American National Standards Institute

ANSI/ISO 9899: 1990

ANSI/ISO C+ Draft Standard

ANSI/ISO C++ Draft Standard

ANSI/ISO draft standard

any

append

append a string

append data to a file

append output symbol (>>)

Apple Computer

Apple Macintosh

arbitrary range of subscripts

architecture of a software system

argc

argument

argument checking disabled

argument for a macro

arguments in correct order

arguments passed to member-object constructors

argv

argv[]

arithmetic

arithmetic and logic unit (ALU)

arithmetic average

arithmetic calculations

arithmetic mean (average)

arithmetic operators

arithmetic overflow

arithmetic overflow error

arithmetic underflow error

"arity" of an operator

array

array assignment

array bounds

array bounds checking

Array class

array comparison

array initializer list

array input/output

array name as a constant pointer

array name as a pointer

array name as constant pointer to beginning of array

array notation

array of bits

array of strings

array size

array sort function

array subscript operator ([])

array subscripting

Array< T >

arrays of pointers to functions

arrays passed by reference

arrays that know their size

arrow

arrow member selection operator (->)

arrow operator (->)

ASCII (American Standard Code for Information Interchange)

ASCII character set

ASCII characters

ASCII decimal equivalent of a character

assembler

assembly language

assert

assert macro

assert to test that new succeeded

<assert.h>

assertion

assign
assign one iterator to another

assign()

assigned the value of

assigning a structure to a structure of the same type

assigning a union to another union of the same type

assigning character strings to string objects

assigning class objects

assigning derived-class pointers to base-class pointers

assignment
assignment operator (=)

assignment operator function

assignment statement

assignment suppression character *

associate from right to left

associate left to right

associate right to left

association

associative array

associative container

associativity

associativity not changed by overloading

associativity of operators

asterisk operator (*)

asynchronous

at()
atexit

atof

atoi

atol

attribute

attributes of a variable

attributes of objects

audio

auto

auto_ptr

auto_ptr object

auto_ptr object goes out of scope

auto_ptr overloaded * operator

auto_ptr overloaded -> operator

automated teller machine

automatic array

automatic local array

automatic local objects

automatic local variable

automatic object

automatic objects in a try block

automatic storage class

automatic variable

automatically destroyed

automobile

average

average of several integers

averaging calculation

avoid a function call

avoid repeating code

avoid self assignment
aware of

B
B

Babbage, Charles

back

back_inserter

backslash

backslash (\\)

backslash zero

backspace ('\\b')

backward pointer

backwards traversal

bad member function

bad_alloc exception

bad_cast

bad_exception

bad_typeid

badbit

Bank account program

banking system

bar chart

base

base 10

base 12 number system

base 16

base 2

base 8

base case

base class

base class Employee

base class exception

base class of the class of a thrown object

base class pointer

base e

base specified for a stream

base-class assignment operators not inherited by derived class

base-class catch

base-class constructor

base-class destructor

base-class initializer

base-class member accessibility in a derived class

base-class part of a derived-class object

base-class pointer

base-class pointer to derived-class object

base-class reference

basefield

BASIC

basic_istringstream< char >

basic_ostringstream< char >

basic_string

basic_string< char >

basics of computers

batch

batch processing

BCPL

begin
beginning of a file

beginning of a stream

behavior

behaviors

behaviors of objects

bell

bell

Bell Laboratories

bibliography

bidirectional iterator

bidirectional iterator operations

binary

binary (base 2) number system

binary arithmetic operators

binary comparison function

binary digit

binary digits

binary function

binary function object

binary integer

binary number

binary number system

binary operator

binary operator +

binary operator +=

binary predicate function

binary representation

binary scope resolution operator (::)

binary search

binary search tree

binary system

binary tree

binary tree delete

binary tree search

binary tree sort

binary tree with duplicates

binary_function< T, T, T >
binary_search
binary-to-decimal conversion

bit

bit field

bit field manipulation

bit field member of a structure

bit fields save space

bit manipulation

bitand

"bits-and-bytes" level

<bitset>

bitset

bitwise AND

bitwise AND assignment

bitwise AND assignment operator (&=)

bitwise AND operator (&)

bitwise assignment operator keywords

bitwise assignment operators

bitwise complement

bitwise complement operator (~)

bitwise exclusive OR

bitwise exclusive OR assignment operator (^=)

bitwise exclusive OR operator (^)

bitwise inclusive OR

bitwise inclusive OR assignment

bitwise inclusive OR assignment operator (|=)

bitwise inclusive OR operator (|)

bitwise left shift assignment operator (<<=)

bitwise left shift operator (<<)

bitwise logical OR

bitwise logical XOR

bitwise operator keywords

bitwise operators

bitwise OR operator (|)

bitwise right shift operator (>>)

bitwise right shift with sign operator (>>=)

bitwise-or operation

blank

blank character

blank line

blank lines

block

block is active

block is exited

block of data

block of memory

block scope

blueprint

body of a class definition

body of a function

body of a while structure

body of the else

body of the loop

body of the while

Bohm, C.

"bombing"

books

bool

bool value false

bool value true

boolalpha
Borland C++

Borland C++ 5.0 Development Suite

Borland C++ compiler

Borland Turbo C++ Visual Edition for Windows compiler

boss

bottom of a stack

boundary alignment

boundary of a storage unit

bounds checking

box

braces

braces ( { } )

braces in a do/while structure

brackets

branch negative

branch zero

branch zero instruction

branching logic

break

break statement

"brute force" computing

bubble sort

bubble sort program

bucket sort

buffer fills

buffer is filled

buffer is flushed

buffered output

buffered standard error stream

buffering

bug

bug avoidance

Building A Compiler

"building block approach"

Building Your Own Compiler

building-block appearance

built-in data types

built-in types

business software

Byron, Lord

byte